using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("CollectionDeck")]
	public class CollectionDeck : MonoClass
	{
		public static int DefaultMaxDeckNameCharacters => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "CollectionDeck", "DefaultMaxDeckNameCharacters");

		public string m_name => method_4("m_name");

		public List<CollectionDeckSlot> m_slots => method_3<Class271<CollectionDeckSlot>>("m_slots")?.method_25();

		public bool m_netContentsLoaded => method_2<bool>("m_netContentsLoaded");

		public bool m_isSavingContentChanges => method_2<bool>("m_isSavingContentChanges");

		public bool m_isSavingNameChanges => method_2<bool>("m_isSavingNameChanges");

		public bool m_isBeingDeleted => method_2<bool>("m_isBeingDeleted");

		public ShareableDeck m_createdFromShareableDeck => method_3<ShareableDeck>("m_createdFromShareableDeck");

		public long ID => method_2<long>("ID");

		public string HeroCardID => method_4("HeroCardID");

		public TAG_PREMIUM HeroPremium => method_2<TAG_PREMIUM>("HeroPremium");

		public bool HeroOverridden => method_2<bool>("HeroOverridden");

		public int CardBackID => method_2<int>("CardBackID");

		public bool CardBackOverridden => method_2<bool>("CardBackOverridden");

		public int SeasonId => method_2<int>("SeasonId");

		public bool NeedsName => method_2<bool>("NeedsName");

		public long SortOrder => method_2<long>("SortOrder");

		public ulong CreateDate => method_2<ulong>("CreateDate");

		public bool Locked => method_2<bool>("Locked");

		public string HeroPowerCardID => method_4("HeroPowerCardID");

		public bool m_isWild => method_2<bool>("m_isWild");

		public string Name => method_13("get_Name");

		public bool IsWild => method_11<bool>("get_IsWild", Array.Empty<object>());

		public bool IsBrawlDeck => method_11<bool>("get_IsBrawlDeck", Array.Empty<object>());

		public bool IsTourneyValid => method_11<bool>("get_IsTourneyValid", Array.Empty<object>());

		public ShareableDeck CreatedFromShareableDeck => method_14<ShareableDeck>("get_CreatedFromShareableDeck", Array.Empty<object>());

		public CollectionDeck(IntPtr address, string className)
			: base(address, className)
		{
		}

		public CollectionDeck(IntPtr address)
			: this(address, "CollectionDeck")
		{
		}

		public static string GetUserFriendlyCopyErrorMessageFromDeckRuleViolation(DeckRuleViolation violation)
		{
			return MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "CollectionDeck", "GetUserFriendlyCopyErrorMessageFromDeckRuleViolation", violation);
		}

		public new string ToString()
		{
			return method_13("ToString");
		}

		public void MarkNetworkContentsLoaded()
		{
			method_8("MarkNetworkContentsLoaded");
		}

		public bool NetworkContentsLoaded()
		{
			return method_11<bool>("NetworkContentsLoaded", Array.Empty<object>());
		}

		public void MarkBeingDeleted()
		{
			method_8("MarkBeingDeleted");
		}

		public bool IsBeingDeleted()
		{
			return method_11<bool>("IsBeingDeleted", Array.Empty<object>());
		}

		public bool IsSavingChanges()
		{
			return method_11<bool>("IsSavingChanges", Array.Empty<object>());
		}

		public bool IsBasicDeck()
		{
			return method_11<bool>("IsBasicDeck", Array.Empty<object>());
		}

		public bool IsInnkeeperDeck()
		{
			return method_11<bool>("IsInnkeeperDeck", Array.Empty<object>());
		}

		public int GetTotalCardCount()
		{
			return method_11<int>("GetTotalCardCount", Array.Empty<object>());
		}

		public int GetTotalOwnedCardCount()
		{
			return method_11<int>("GetTotalOwnedCardCount", Array.Empty<object>());
		}

		public int GetTotalValidCardCount()
		{
			return method_11<int>("GetTotalValidCardCount", Array.Empty<object>());
		}

		public int GetTotalInvalidCardCount()
		{
			return method_11<int>("GetTotalInvalidCardCount", Array.Empty<object>());
		}

		public int GetTotalUnownedCardCount()
		{
			return method_11<int>("GetTotalUnownedCardCount", Array.Empty<object>());
		}

		public List<CollectionDeckSlot> GetSlots()
		{
			return method_14<Class271<CollectionDeckSlot>>("GetSlots", Array.Empty<object>())?.method_25();
		}

		public int GetSlotCount()
		{
			return method_11<int>("GetSlotCount", Array.Empty<object>());
		}

		public bool IsValidSlot(CollectionDeckSlot slot)
		{
			return method_11<bool>("IsValidSlot", new object[1] { slot });
		}

		public bool SlotMatchesFormat(CollectionDeckSlot slot)
		{
			return method_11<bool>("SlotMatchesFormat", new object[1] { slot });
		}

		public bool HasReplaceableSlot()
		{
			return method_11<bool>("HasReplaceableSlot", Array.Empty<object>());
		}

		public CollectionDeckSlot GetSlotByIndex(int slotIndex)
		{
			return method_14<CollectionDeckSlot>("GetSlotByIndex", new object[1] { slotIndex });
		}

		public CollectionDeckSlot GetExistingSlot(CollectionDeckSlot searchSlot)
		{
			return method_14<CollectionDeckSlot>("GetExistingSlot", new object[1] { searchSlot });
		}

		public DeckRuleset GetRuleset()
		{
			return method_14<DeckRuleset>("GetRuleset", Array.Empty<object>());
		}

		public bool IsValidForFormat(bool isFormatWild)
		{
			return method_11<bool>("IsValidForFormat", new object[1] { isFormatWild });
		}

		public bool InsertSlotByDefaultSort(CollectionDeckSlot slot)
		{
			return method_11<bool>("InsertSlotByDefaultSort", new object[1] { slot });
		}

		public void CopyFrom(CollectionDeck otherDeck)
		{
			method_8("CopyFrom", otherDeck);
		}

		public void CopyContents(CollectionDeck otherDeck)
		{
			method_8("CopyContents", otherDeck);
		}

		public void FillFromShareableDeck(ShareableDeck shareableDeck)
		{
			method_8("FillFromShareableDeck", shareableDeck);
		}

		public void FillFromTemplateDeck(CollectionManager.TemplateDeck tplDeck)
		{
			method_8("FillFromTemplateDeck", tplDeck);
		}

		public int ReconcileUnownedCards()
		{
			return method_11<int>("ReconcileUnownedCards", Array.Empty<object>());
		}

		public int GetUnownedCardIdCount(string cardID)
		{
			return method_11<int>("GetUnownedCardIdCount", new object[1] { cardID });
		}

		public int GetInvalidCardIdCount(string cardID)
		{
			return method_11<int>("GetInvalidCardIdCount", new object[1] { cardID });
		}

		public int GetCardIdCount(string cardID, bool includeUnowned)
		{
			return method_11<int>("GetCardIdCount", new object[2] { cardID, includeUnowned });
		}

		public int GetCardCountFirstMatchingSlot(string cardID, TAG_PREMIUM premium)
		{
			return method_11<int>("GetCardCountFirstMatchingSlot", new object[2] { cardID, premium });
		}

		public int GetCardCountAllMatchingSlots(string cardID)
		{
			return method_10<int>("GetCardCountAllMatchingSlots", new Class276.Enum20[1] { Class276.Enum20.String }, new object[1] { cardID });
		}

		public int GetCardCountAllMatchingSlots(string cardID, TAG_PREMIUM premium)
		{
			return method_10<int>("GetCardCountAllMatchingSlots", new Class276.Enum20[2]
			{
				Class276.Enum20.String,
				Class276.Enum20.ValueType
			}, new object[2] { cardID, premium });
		}

		public int GetValidCardCount(string cardID, TAG_PREMIUM premium, bool valid)
		{
			return method_11<int>("GetValidCardCount", new object[3] { cardID, premium, valid });
		}

		public int GetOwnedCardCount(string cardID, TAG_PREMIUM premium, bool owned)
		{
			return method_11<int>("GetOwnedCardCount", new object[3] { cardID, premium, owned });
		}

		public int CountFilterMisses(DeckRuleset deckRuleset)
		{
			return method_11<int>("CountFilterMisses", new object[1] { deckRuleset });
		}

		public List<CollectionDeckSlot> GetFilterMisses(DeckRuleset deckRuleset)
		{
			return method_14<Class271<CollectionDeckSlot>>("GetFilterMisses", new object[1] { deckRuleset })?.method_25();
		}

		public void ClearSlotContents()
		{
			method_8("ClearSlotContents");
		}

		public bool CanAddOwnedCard(string cardID, TAG_PREMIUM premium)
		{
			return method_11<bool>("CanAddOwnedCard", new object[2] { cardID, premium });
		}

		public bool AddCard(EntityDef cardEntityDef, TAG_PREMIUM premium, bool exceedMax)
		{
			return method_10<bool>("AddCard", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType,
				Class276.Enum20.Boolean
			}, new object[3] { cardEntityDef, premium, exceedMax });
		}

		public bool AddCard(string cardID, TAG_PREMIUM premium, bool exceedMax)
		{
			return method_10<bool>("AddCard", new Class276.Enum20[3]
			{
				Class276.Enum20.String,
				Class276.Enum20.ValueType,
				Class276.Enum20.Boolean
			}, new object[3] { cardID, premium, exceedMax });
		}

		public void AddCard_IgnoreValidity(string cardID, TAG_PREMIUM premium, int countToAdd)
		{
			method_8("AddCard_IgnoreValidity", cardID, premium, countToAdd);
		}

		public bool RemoveCard(string cardID, TAG_PREMIUM premium, bool valid, bool removeAllCopies)
		{
			return method_11<bool>("RemoveCard", new object[4] { cardID, premium, valid, removeAllCopies });
		}

		public void OnContentChangesComplete()
		{
			method_8("OnContentChangesComplete");
		}

		public void OnNameChangeComplete()
		{
			method_8("OnNameChangeComplete");
		}

		public bool CanBeDeleted()
		{
			return method_11<bool>("CanBeDeleted", Array.Empty<object>());
		}

		public void SendChanges()
		{
			method_8("SendChanges");
		}

		public void SetShareableDeckCreatedFrom(ShareableDeck shareableDeck)
		{
			method_8("SetShareableDeckCreatedFrom", shareableDeck);
		}

		public bool CanInsertCard(string cardID, TAG_PREMIUM premium)
		{
			return method_11<bool>("CanInsertCard", new object[2] { cardID, premium });
		}

		public bool InsertSlot(int slotIndex, CollectionDeckSlot slot)
		{
			return method_11<bool>("InsertSlot", new object[2] { slotIndex, slot });
		}

		public void ForceRemoveSlot(CollectionDeckSlot slot)
		{
			method_8("ForceRemoveSlot", slot);
		}

		public void RemoveSlot(CollectionDeckSlot slot)
		{
			method_8("RemoveSlot", slot);
		}

		public void OnSlotEmptied(CollectionDeckSlot slot)
		{
			method_8("OnSlotEmptied", slot);
		}

		public void UpdateSlotIndices(int indexA, int indexB)
		{
			method_8("UpdateSlotIndices", indexA, indexB);
		}

		public CollectionDeckSlot FindSlotByCardId(string cardID)
		{
			return method_14<CollectionDeckSlot>("FindSlotByCardId", new object[1] { cardID });
		}

		public CollectionDeckSlot FindOwnedSlotByCardId(string cardID, bool owned)
		{
			return method_14<CollectionDeckSlot>("FindOwnedSlotByCardId", new object[2] { cardID, owned });
		}

		public CollectionDeckSlot FindValidSlotByCardId(string cardID, bool valid)
		{
			return method_14<CollectionDeckSlot>("FindValidSlotByCardId", new object[2] { cardID, valid });
		}

		public List<Network.CardUserData> CardUserDataFromSlot(CollectionDeckSlot deckSlot, bool deleted)
		{
			return method_14<Class271<Network.CardUserData>>("CardUserDataFromSlot", new object[2] { deckSlot, deleted })?.method_25();
		}

		public List<Network.CardUserData> GenerateContentChanges(CollectionDeck baseDeck)
		{
			return method_14<Class271<Network.CardUserData>>("GenerateContentChanges", new object[1] { baseDeck })?.method_25();
		}

		public int GetInsertionIdxByDefaultSort(CollectionDeckSlot slot)
		{
			return method_11<int>("GetInsertionIdxByDefaultSort", new object[1] { slot });
		}

		public TAG_CLASS GetClass()
		{
			return method_11<TAG_CLASS>("GetClass", Array.Empty<object>());
		}

		public ShareableDeck GetShareableDeck()
		{
			return method_14<ShareableDeck>("GetShareableDeck", Array.Empty<object>());
		}

		public void LogDeckStringInformation()
		{
			method_8("LogDeckStringInformation");
		}

		public List<DeckMaker.DeckFill> GetDeckFillFromString(string deckString)
		{
			return method_14<Class271<DeckMaker.DeckFill>>("GetDeckFillFromString", new object[1] { deckString })?.method_25();
		}

		public bool ShouldSplitSlotsByValidity()
		{
			return method_11<bool>("ShouldSplitSlotsByValidity", Array.Empty<object>());
		}
	}
}
